home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Applications / Games / Tetris / Source / RCS / TetApp.m,v < prev    next >
Encoding:
Text File  |  1975-04-26  |  12.9 KB  |  722 lines
  1. head     1.8;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ;
  6. comment  @@;
  7.  
  8.  
  9. 1.8
  10. date     92.03.01.10.27.03;  author melling;  state Exp;
  11. branches ;
  12. next     1.7;
  13.  
  14. 1.7
  15. date     92.03.01.05.07.46;  author melling;  state Exp;
  16. branches ;
  17. next     1.6;
  18.  
  19. 1.6
  20. date     92.02.29.20.35.50;  author melling;  state Exp;
  21. branches ;
  22. next     1.5;
  23.  
  24. 1.5
  25. date     92.02.28.05.19.04;  author melling;  state Exp;
  26. branches ;
  27. next     1.4;
  28.  
  29. 1.4
  30. date     91.12.19.10.12.46;  author melling;  state Exp;
  31. branches ;
  32. next     1.3;
  33.  
  34. 1.3
  35. date     91.12.16.17.22.14;  author melling;  state Exp;
  36. branches ;
  37. next     1.2;
  38.  
  39. 1.2
  40. date     91.12.07.07.49.14;  author melling;  state Exp;
  41. branches ;
  42. next     1.1;
  43.  
  44. 1.1
  45. date     91.12.07.03.37.04;  author melling;  state Exp;
  46. branches ;
  47. next     ;
  48.  
  49.  
  50. desc
  51. @Tetris 1.1
  52. @
  53.  
  54.  
  55. 1.8
  56. log
  57. @Release 1.3
  58. @
  59. text
  60. @
  61. #import <appkit/Button.h>
  62. #import <appkit/ButtonCell.h>
  63. #import <appkit/Panel.h>
  64. #import <appkit/Window.h>
  65. #import <appkit/TextField.h>
  66. #import <appkit/graphics.h>
  67. #import <string.h>
  68. #import <ctype.h>
  69.  
  70. #import "TetApp.h"
  71. #import "NextMatrix.h"
  72. #import "ScoreKeeper.h"
  73. #import "TetMatrix.h"
  74.  
  75. @@implementation TetApp
  76.  
  77. - initForColor
  78. {
  79.     const NXScreen *deepestScreen;
  80.     const char *str;
  81.  
  82.  
  83.     str = NXGetDefaultValue([NXApp appName], "ColorOff");
  84.     if (str != NULL && (strcmp(str, "YES") == 0)) { 
  85.         colorOff = YES;
  86.         gameInColor = NO;
  87. #ifdef DEBUG
  88.         fprintf(stderr, "Game wants to be B&W\n");
  89. #endif
  90.     } else {
  91.         colorOff = NO;
  92.         deepestScreen = [NXApp colorScreen];
  93.         
  94.         if ( deepestScreen->depth  != NX_TwoBitGrayDepth ) {
  95.             // Then 12 bit color should be more than enough
  96.             [tetrisWindow setDepthLimit:NX_TwelveBitRGBDepth];
  97.             gameInColor = YES;
  98.         } else {
  99.             gameInColor = NO;
  100.         }
  101.     }
  102.     return self;
  103. }
  104.  
  105.  
  106. + new
  107. {
  108.     self = [super new];
  109.     [self setDelegate:self];
  110.     [self initForColor];
  111.     started = paused = NO;
  112.     numRandomRows = 4;
  113.     return self;
  114. }
  115.  
  116.  
  117. - setLevelLeft:anObject
  118. {
  119.     levelLeft = anObject;
  120.     [[levelLeft cell] setHighlightsBy:NX_CONTENTS | NX_CHANGEGRAY];
  121.     [levelLeft sendActionOn:NX_MOUSEDOWNMASK];
  122.     return self;
  123. }
  124.  
  125. - setLevelRight:anObject
  126. {
  127.     levelRight = anObject;
  128.     [[levelRight cell] setHighlightsBy:NX_CONTENTS | NX_CHANGEGRAY];
  129.     [levelRight sendActionOn:NX_MOUSEDOWNMASK];
  130.     return self;
  131. }
  132.  
  133. - (BOOL) isGameColor
  134. {
  135.     return gameInColor;
  136. }
  137.  
  138. - setTetrisWindow:anObject
  139. {
  140.     tetrisWindow = anObject;
  141.     [tetrisWindow setDelegate:self];
  142.     [tetrisWindow setMiniwindowIcon:"Tetris"];
  143.     return self;
  144. }
  145.  
  146.  
  147. - appDidInit:sender
  148. {
  149.     const char *str;
  150.     int levelValue;
  151.  
  152.     [controlWindow removeFromEventMask:NX_KEYDOWNMASK|NX_KEYUPMASK];
  153.     [controlWindow orderFront:self];
  154.  
  155.     str = NXGetDefaultValue([NXApp appName], "CurrentLevel");
  156.     if (str != NULL) { 
  157.         sscanf(str, "%d", &levelValue);
  158.         [level setIntValue: levelValue];
  159.         [self updateLeft: levelValue];
  160.         [self updateRight: levelValue];
  161. #ifdef DEBUG
  162.         fprintf(stderr, "Setting current level to %d\n", levelValue);
  163. #endif
  164.     }
  165.  
  166.     str = NXGetDefaultValue([NXApp appName], "RandomRows");
  167.     if (str != NULL) { 
  168.         sscanf(str, "%d", &numRandomRows);
  169.         [randomField setIntValue:numRandomRows];
  170.         [randomSlider setIntValue:numRandomRows];
  171. #ifdef DEBUG
  172.         fprintf(stderr, "Setting number Random rows to %d\n", numRandomRows);
  173. #endif
  174.     }
  175.     str = NXGetDefaultValue([NXApp appName], "ShowNext");
  176.     if (str != NULL) {
  177.         if (strcmp(str, "YES") == 0) {
  178.             [showNextSwitch setIntValue: YES];
  179.             [showNext showNext:showNextSwitch]; // ID is actually ignored
  180.         }
  181.     }
  182.     [colorSwitch setIntValue: colorOff];
  183.  
  184.     [tetrisWindow orderWindow:NX_ABOVE relativeTo:0];
  185.     [tetrisWindow makeKeyWindow];
  186.  
  187.     return self;
  188. }
  189.  
  190. - (BOOL) gamePaused
  191. {
  192.     return paused;
  193. }
  194.  
  195. - keyDown:(NXEvent *)theEvent
  196. {
  197.     unsigned short charCode;
  198.     printf("Keydown in TetApp\n");
  199.  
  200.     charCode = theEvent->data.key.charCode;
  201.     if (isupper(charCode))
  202.       charCode = tolower(charCode);
  203.  
  204.     switch (charCode) {
  205.      case 13:                          // Pause if the user hits return
  206.         [self pause:self];
  207.     }
  208.     return self;
  209. }
  210.  
  211. - resignActiveApp
  212. {
  213.     if (started && !paused)
  214.         [self pause:self];
  215.     return [super resignActiveApp];
  216. }
  217.  
  218. - updateLeft:(int) theLevel
  219. {
  220.     if (theLevel <= MIN_LEVEL) {
  221.         [[levelLeft setEnabled:NO] setIcon:"scrollMenuLeftD"];
  222.     } else {
  223.         [[levelLeft setEnabled:YES] setIcon:"scrollMenuLeft"];
  224.     }
  225.     return self;
  226. }
  227.  
  228. - updateRight:(int) theLevel
  229. {
  230.     if (theLevel >= MAX_LEVEL) {
  231.         [[levelRight setEnabled:NO] setIcon:"scrollMenuRightD"];
  232.     } else {
  233.         [[levelRight setEnabled:YES] setIcon:"scrollMenuRight"];
  234.     }
  235.     return self;
  236. }
  237.  
  238. - start:sender
  239. {
  240.     int levelValue = [level intValue];
  241.     
  242.     if (started) {
  243.         if (paused)
  244.           [self pause:sender];
  245.         [tetrisView stop:sender];
  246.         [[tetrisView window] disableFlushWindow];
  247.         [showNext end:self];
  248.         [startButton setTitle:"New game"];
  249.         [pauseButton setEnabled:NO];
  250.         [levelLeft setTransparent:NO];
  251.         [levelRight setTransparent:NO];
  252.         [self updateLeft: levelValue];
  253.         [self updateRight: levelValue];
  254.         [[[tetrisView window] reenableFlushWindow] flushWindow];
  255.         started = NO;
  256.     } else {
  257.         [[tetrisView window] disableFlushWindow];
  258.         [showNext start:self];
  259.         [startButton setTitle:"Abort"];
  260.         [pauseButton setEnabled:YES];
  261.         [scoreKeeper setZero];
  262.         [tetrisView setScoreKeeper:scoreKeeper];
  263.         [[levelLeft setTransparent:YES] setEnabled:NO];
  264.         [[levelRight setTransparent:YES] setEnabled:NO];
  265.         [[[tetrisView window] reenableFlushWindow] flushWindow];
  266.         [tetrisView newGame:levelValue];
  267.         started = YES;
  268.     }
  269.     return self;
  270. }
  271.  
  272. - pause:sender
  273. {
  274.     [[tetrisView window] disableFlushWindow];
  275.     if (paused) {
  276.         [pauseButton setTitle:"Pause"];
  277.         [pauseDisplay setStringValueNoCopy:""];
  278.         [tetrisView continue:sender];
  279.         paused = NO;
  280.     } else {
  281.         [tetrisView pause:sender];
  282.         [pauseButton setTitle:"Continue"];
  283.         [pauseDisplay setStringValueNoCopy:"PAUSED"];
  284.         paused = YES;
  285.     }
  286.     [[[tetrisView window] reenableFlushWindow] flushWindow];
  287.     return self;
  288. }
  289.  
  290. - gameOver
  291. {
  292.     int levelValue = [level intValue];
  293.     
  294.     [[tetrisView window] disableFlushWindow];
  295.     [showNext end:self];
  296.     [startButton setTitle:"New game"];
  297.     [pauseButton setEnabled:NO];
  298.     [levelLeft setTransparent:NO];
  299.     [levelRight setTransparent:NO];
  300.     [self updateLeft: levelValue];
  301.     [self updateRight: levelValue];
  302.     [[[tetrisView window] reenableFlushWindow] flushWindow];
  303.     NXPing();
  304.     started = NO;
  305.     
  306.     [scoreKeeper updateHighScores:levelValue];
  307.     return self;
  308. }
  309.  
  310. - levelLeft:sender
  311. {
  312.     int levelValue = [level intValue];
  313.     
  314.     if (levelValue != MIN_LEVEL) {
  315.         [level setIntValue:--levelValue];
  316.         [self updateLeft: levelValue];
  317.         [self updateRight: levelValue];
  318.     }
  319.     return self;
  320. }
  321.  
  322. - levelRight:sender
  323. {
  324.     int levelValue = [level intValue];
  325.     
  326.     if (levelValue != MAX_LEVEL) {
  327.         [level setIntValue:++levelValue];
  328.         [self updateLeft: levelValue];
  329.         [self updateRight: levelValue];
  330.     }
  331.     return self;
  332. }
  333.  
  334. /*
  335.  * Set the number of rows where random pieces will appear.
  336.  */
  337. - setRandomRows:sender
  338. {
  339.     int tmp;
  340.     tmp = [sender intValue];
  341.  
  342.     // Will always be valid since slider is the only object that can call me!?
  343.     if (tmp >= 0  && tmp <=10) {
  344.         numRandomRows = tmp;
  345.         [randomField setIntValue: tmp];
  346.     } else {
  347.         [randomField setIntValue:numRandomRows];
  348.     }
  349.     return self;
  350. }
  351.  
  352. /*
  353.  * Let user use monochrome blocks to get better speed.
  354.  */
  355. - adjustColor:sender
  356. {
  357.     int value = [sender intValue];
  358.     colorOff = value;
  359.     if ( (colorOff == NO) && ([NXApp colorScreen] != NX_TwoBitGrayDepth)) {
  360.         gameInColor = YES;
  361.     } 
  362.     if (colorOff == YES) {
  363.         [tetrisWindow setDepthLimit:NX_TwoBitGrayDepth];
  364.     } else {
  365.         [tetrisWindow setDepthLimit:NX_TwelveBitRGBDepth];
  366.     }
  367.     if (value == YES) {
  368.         fprintf(stderr, "Turing color off\n");
  369.     } else {
  370.         fprintf(stderr, "Turing color on\n");
  371.     }
  372.     return self;
  373. }
  374.  
  375. /*
  376.  * User has clicked quit.
  377.  *   If the game is in progress then verify the quit.
  378.  *   Save high scores and default values.
  379.  */
  380. - terminate:sender
  381. {
  382.     char buf[20];
  383.  
  384.     if (started &&
  385.          NXRunAlertPanel("Quit", "Game is still in progress. Really quit?",
  386.                               "Quit", "Cancel", NULL) == NX_ALERTALTERNATE)
  387.       return self;
  388.  
  389.     // Clean up and die
  390.     [scoreKeeper writeScores];
  391.     sprintf(buf,"%d", [level intValue]);
  392.     NXWriteDefault ([NXApp appName], "CurrentLevel", buf);
  393.     NXWriteDefault ([NXApp appName], "ColorOff", ([colorSwitch intValue]) ? "YES" : "NO");
  394.     sprintf(buf,"%d", numRandomRows);
  395.     NXWriteDefault ([NXApp appName], "RandomRows", buf);
  396.     NXWriteDefault ([NXApp appName], "ShowNext", ([showNextSwitch intValue]) ? "YES" : "NO");
  397.     return [super terminate:sender];
  398. }
  399.  
  400. /*
  401.  *  Allow the user to set the blocks images that make up the pieces
  402.  */
  403. - setBlocks:sender
  404. {
  405.     return self;
  406. }
  407.  
  408. - windowWillMiniaturize:sender toMiniwindow:miniwindow
  409. {
  410.     if (started && !paused)
  411.         [self pause:sender];
  412.     return self;
  413. }
  414.  
  415. - windowDidMove:sender
  416. {
  417.     NXRect aRect;
  418.     float newX, newY;
  419.  
  420.     [[tetrisView window] getFrame:&aRect];
  421.     newX = aRect.origin.x + aRect.size.width + 5.; 
  422.     newY = aRect.origin.y;
  423.     [controlWindow moveTo: newX :newY];
  424.  
  425.     return self;
  426. }
  427.  
  428. /*
  429.  * Must bring the control panel to the front too.
  430.  */
  431. - windowDidBecomeKey:sender
  432. {
  433.     [controlWindow orderFront:self];
  434.     return self;
  435. }
  436. @@end
  437. @
  438.  
  439.  
  440. 1.7
  441. log
  442. @*** empty log message ***
  443. @
  444. text
  445. @d9 1
  446. d18 29
  447. d51 1
  448. d53 1
  449. a53 1
  450.  
  451. a80 3
  452.     const NXScreen *deepestScreen;
  453.     char *str;
  454.  
  455. a83 15
  456.  
  457.     str= NXGetDefaultValue([NXApp appName], "ColorOff");
  458.     if (str != NULL && strcmp(str, "YES")) { 
  459.         gameInColor = NO;
  460.     } else {                              // 
  461.         deepestScreen=[NXApp colorScreen];
  462.         
  463.         if ( deepestScreen->depth  != NX_TwoBitGrayDepth ) {
  464.             // Then 12 bit color should be more than enough
  465.             [tetrisWindow setDepthLimit:NX_TwelveBitRGBDepth];
  466.             gameInColor = YES;
  467.         } else {
  468.             gameInColor = NO;
  469.         }
  470.     }
  471. d90 1
  472. a90 1
  473.     char *levelStr;
  474. d95 4
  475. a98 4
  476. #ifdef 0
  477.     levelStr = NXGetDefaultValue([NXApp appName], "CurrentLevel");
  478.     if (levelStr != NULL) { 
  479.         sscanf(levelStr, "%d", levelValue);
  480. d102 3
  481. d106 8
  482. d115 11
  483. d131 21
  484. d275 21
  485. d299 10
  486. a308 2
  487.  
  488.     if (value = YES) {
  489. d315 6
  490. d332 1
  491. a332 2
  492.     sprintf(buf,"%d", level);
  493.  
  494. d334 4
  495. a337 2
  496.     NXWriteDefault ([NXApp appName], "ColorOff", (gameInColor) ? "NO" : "YES");
  497.  
  498. d366 9
  499. @
  500.  
  501.  
  502. 1.6
  503. log
  504. @*** empty log message ***
  505. @
  506. text
  507. @d5 1
  508. d8 2
  509. d23 1
  510. a23 2
  511. //    tetrisView = [[TetMatrix alloc] initframe
  512.     return self;
  513. d26 1
  514. d51 1
  515. d57 2
  516. a58 13
  517.     deepestScreen=[NXApp colorScreen];
  518.  
  519.     if ( deepestScreen->depth  != NX_TwoBitGrayDepth ) {
  520.         // Then 12 bit color should be more than enough
  521.         [tetrisWindow setDepthLimit:NX_TwelveBitRGBDepth];
  522. #ifdef DEBUG
  523.         printf("Setting screen depth to 12 bits/pixel.\n"); 
  524. #endif
  525.         gameInColor = YES;
  526.     } else {
  527. #ifdef DEBUG
  528.         printf("Setting screen depth to 2 bits/pixel.\n"); 
  529. #endif
  530. d60 10
  531. d77 2
  532. a78 1
  533. //    NXRect aRect = {0.0, 0.0, 0.0, 0.0};
  534. d80 12
  535. a91 2
  536. //    [controlBox moveTo: 400. :0.];
  537.    [tetrisWindow makeKeyWindow];
  538. a92 3
  539.     // Make the Window the proper size
  540. //    [tetrisWindow sizeWindow: 342.+104. :837+15.];
  541.     
  542. d105 5
  543. a109 4
  544.     if (theLevel <= MIN_LEVEL)
  545.       [[levelLeft setEnabled:NO] setIcon:"scrollMenuLeftD"];
  546.     else
  547.       [[levelLeft setEnabled:YES] setIcon:"scrollMenuLeft"];
  548. d115 6
  549. a120 5
  550.     if (theLevel >= MAX_LEVEL)
  551.         [[self->levelRight setEnabled:NO] setIcon:"scrollMenuRightD"];
  552.     else
  553.         [[self->levelRight setEnabled:YES] setIcon:"scrollMenuRight"];
  554.      return self;
  555. d219 11
  556. d232 2
  557. d238 2
  558. d241 5
  559. d249 3
  560. a253 1
  561.  
  562. d264 12
  563. @
  564.  
  565.  
  566. 1.5
  567. log
  568. @*** empty log message ***
  569. @
  570. text
  571. @d79 3
  572. @
  573.  
  574.  
  575. 1.4
  576. log
  577. @*** empty log message ***
  578. @
  579. text
  580. @d40 5
  581. d52 1
  582. d61 1
  583. a61 1
  584.  
  585. d66 1
  586. d74 1
  587. a74 1
  588.     NXRect aRect = {0.0, 0.0, 0.0, 0.0};
  589. d76 1
  590. a78 5
  591. //    [[NXImage findImageNamed:"Block1"] getSize:&size];
  592. //    resize(&size);
  593. //    aRect.size.height = 25 * 16.0;
  594. //    aRect.size.width = 10 * 16.0;
  595.  
  596. d89 1
  597. a89 1
  598. - updateLeft:(int) level
  599. d91 1
  600. a91 1
  601.     if (level <= MIN_LEVEL)
  602. d98 1
  603. a98 1
  604. - updateRight:(int) level
  605. d100 1
  606. a100 1
  607.     if (level >= MAX_LEVEL)
  608. @
  609.  
  610.  
  611. 1.3
  612. log
  613. @*** empty log message ***
  614. @
  615. text
  616. @a10 1
  617. #import "Cheater.h"
  618. d16 5
  619. a20 6
  620.     self = [super new];
  621.     [self setDelegate:self];
  622.     started = paused = NO;
  623. #ifdef DEBUG
  624. //     aCheater = [[Cheater alloc] init];
  625. #endif
  626. a63 8
  627. /*
  628.  *  The Cheater Object will tell us its id.
  629.  */
  630. - setCheater:anObject
  631. {
  632.     aCheater = anObject;
  633.     return self;
  634. }
  635. d65 1
  636. a65 4
  637. /*
  638.  * Other objects can request the Cheaters id.
  639.  */
  640. - getCheater
  641. d67 1
  642. a67 2
  643.     return aCheater;
  644. }
  645. a68 2
  646. - appDidInit:sender
  647. {
  648. d70 6
  649. d210 6
  650. d218 2
  651. a219 2
  652. //    if (started && !paused)
  653. //        [self pause:sender];
  654. @
  655.  
  656.  
  657. 1.2
  658. log
  659. @Tetris 1.2
  660. @
  661. text
  662. @d11 1
  663. d20 3
  664. d44 20
  665. a63 5
  666.     tetrisWindow = anObject;
  667.     [tetrisWindow setDelegate:self];
  668.     [tetrisWindow setMiniwindowIcon:"Tetris"];
  669.      [tetrisWindow setDepthLimit:NX_TwelveBitRGBDepth];
  670.     return self;
  671. d66 17
  672. d85 2
  673. a86 2
  674.     [tetrisWindow makeKeyWindow];
  675.     return self;
  676. @
  677.  
  678.  
  679. 1.1
  680. log
  681. @Initial revision
  682. @
  683. text
  684. @d6 1
  685. d43 1
  686. d60 1
  687. a60 1
  688. static void updateLeft(id self, int level)
  689. d62 5
  690. a66 4
  691.     if (level <= MIN_LEVEL)
  692.         [[self->levelLeft setEnabled:NO] setIcon:"scrollMenuLeftD"];
  693.     else
  694.         [[self->levelLeft setEnabled:YES] setIcon:"scrollMenuLeft"];
  695. d69 1
  696. a69 1
  697. static void updateRight(id self, int level)
  698. d75 1
  699. d92 2
  700. a93 2
  701.         updateLeft(self, levelValue);
  702.         updateRight(self, levelValue);
  703. d140 2
  704. a141 2
  705.     updateLeft(self, levelValue);
  706.     updateRight(self, levelValue);
  707. d156 2
  708. a157 2
  709.         updateLeft(self, levelValue);
  710.         updateRight(self, levelValue);
  711. d159 1
  712. d168 2
  713. a169 2
  714.         updateLeft(self, levelValue);
  715.         updateRight(self, levelValue);
  716. d171 1
  717. d186 2
  718. a187 2
  719.     if (started && !paused)
  720.         [self pause:sender];
  721. @
  722.